JavaScript mönstermatchnings-guards: Villkorlig utvärdering av uttryck

JavaScript, även om det inte traditionellt är känt för mönstermatchning som vissa funktionella språk, har utvecklats för att inkludera mer sofistikerad villkorlig logik. En kraftfull funktion som förbättrar utvärderingen av villkorliga uttryck är användningen av mönstermatchnings-guards. Denna artikel utforskar hur du kan utnyttja mönstermatchnings-guards för att skapa mer läsbar, underhållbar och uttrycksfull kod.

Vad är mönstermatchnings-guards?

Mönstermatchning är i allmänhet en teknik där du jämför ett värde mot en uppsättning mönster. Guards utökar detta koncept genom att låta dig lägga till villkorliga uttryck till dina mönster. Tänk på dem som extra filter som måste uppfyllas för att ett mönster ska betraktas som en matchning. I JavaScript manifesteras mönstermatchnings-guards ofta inom switch-satser eller genom bibliotek som erbjuder mer avancerade mönstermatchningsfunktioner.

Även om JavaScript inte har inbyggda mönstermatchningskonstruktioner med guards som är lika eleganta som i språk som Scala eller Haskell, kan vi simulera detta beteende med hjälp av switch-satser, if-else-kedjor och strategisk funktionskomposition.

Simulera mönstermatchning med guards i JavaScript

Låt oss utforska hur vi kan simulera mönstermatchnings-guards i JavaScript med olika metoder.

Använda switch-satser

switch-satsen är ett vanligt sätt att implementera villkorlig logik baserad på att matcha ett värde. Även om den saknar direkt guard-syntax, kan vi kombinera den med ytterligare if-satser inom varje case för att uppnå en liknande effekt.

Exempel: Kategorisera tal baserat på deras värde och paritet.

            
function categorizeNumber(number) {
  switch (typeof number) {
    case 'number':
      if (number > 0 && number % 2 === 0) {
        return 'Positivt jämnt tal';
      } else if (number > 0 && number % 2 !== 0) {
        return 'Positivt udda tal';
      } else if (number < 0 && number % 2 === 0) {
        return 'Negativt jämnt tal';
      } else if (number < 0 && number % 2 !== 0) {
        return 'Negativt udda tal';
      } else {
        return 'Noll';
      }
    default:
      return 'Ogiltig inmatning: Inte ett tal';
  }
}

console.log(categorizeNumber(4));   // Utskrift: Positivt jämnt tal
console.log(categorizeNumber(7));   // Utskrift: Positivt udda tal
console.log(categorizeNumber(-2));  // Utskrift: Negativt jämnt tal
console.log(categorizeNumber(-5));  // Utskrift: Negativt udda tal
console.log(categorizeNumber(0));   // Utskrift: Noll
console.log(categorizeNumber('abc')); // Utskrift: Ogiltig inmatning: Inte ett tal

            

              
                Copy
              
            
          

I detta exempel kontrollerar switch-satsen typen på indata. Inom case 'number'-blocket fungerar en serie if-satser som guards, vilket ytterligare förfinar villkoret baserat på talets värde och om det är jämnt eller udda.

Använda if-else-kedjor

En annan vanlig metod är att använda en kedja av if-else if-else-satser. Detta möjliggör mer komplex villkorlig logik och kan effektivt simulera mönstermatchning med guards.

Exempel: Bearbeta användarinmatning baserat på dess typ och längd.

            
function processInput(input) {
  if (typeof input === 'string' && input.length > 10) {
    return 'Lång sträng: ' + input.toUpperCase();
  } else if (typeof input === 'string' && input.length > 0) {
    return 'Kort sträng: ' + input;
  } else if (typeof input === 'number' && input > 100) {
    return 'Stort tal: ' + input;
  } else if (typeof input === 'number' && input >= 0) {
    return 'Litet tal: ' + input;
  } else {
    return 'Ogiltig inmatning';
  }
}

console.log(processInput('Hello World')); // Utskrift: Lång sträng: HELLO WORLD
console.log(processInput('Hello'));       // Utskrift: Kort sträng: Hello
console.log(processInput(200));           // Utskrift: Stort tal: 200
console.log(processInput(50));            // Utskrift: Litet tal: 50
console.log(processInput(-1));            // Utskrift: Ogiltig inmatning

            

              
                Copy
              
            
          

Här kontrollerar if-else if-else-kedjan både typ och längd/värde på indata, vilket i praktiken fungerar som mönstermatchning med guards. Varje if-villkor kombinerar en typkontroll med ett specifikt villkor (t.ex. input.length > 10), vilket förfinar matchningsprocessen.

Använda funktioner som guards

För mer komplexa scenarier kan du definiera funktioner som fungerar som guards och sedan använda dem i din villkorliga logik. Detta främjar återanvändbarhet och läsbarhet i koden.

Exempel: Validera användarobjekt baserat på flera kriterier.

            
function isAdult(user) {
  return user.age >= 18;
}

function isValidEmail(user) {
  return user.email && user.email.includes('@');
}

function validateUser(user) {
  if (typeof user === 'object' && user !== null) {
    if (isAdult(user) && isValidEmail(user)) {
      return 'Giltig vuxen användare';
    } else if (isAdult(user)) {
      return 'Giltig vuxen användare (ingen e-post)';
    } else {
      return 'Ogiltig användare: Minderårig';
    }
  } else {
    return 'Ogiltig inmatning: Inte ett objekt';
  }
}

const user1 = { age: 25, email: 'test@example.com' };
const user2 = { age: 16, email: 'test@example.com' };
const user3 = { age: 30 };

console.log(validateUser(user1)); // Utskrift: Giltig vuxen användare
console.log(validateUser(user2)); // Utskrift: Ogiltig användare: Minderårig
console.log(validateUser(user3)); // Utskrift: Giltig vuxen användare (ingen e-post)
console.log(validateUser('abc')); // Utskrift: Ogiltig inmatning: Inte ett objekt

            

              
                Copy
              
            
          

I detta exempel fungerar isAdult och isValidEmail som guard-funktioner. Funktionen validateUser kontrollerar om indata är ett objekt och använder sedan dessa guard-funktioner för att ytterligare förfina valideringsprocessen.

Fördelar med att använda mönstermatchnings-guards

• Förbättrad kodläsbarhet: Guards gör din villkorliga logik mer explicit och enklare att förstå.
• Förbättrad kodunderhållbarhet: Genom att separera villkor i distinkta guards kan du ändra och testa dem oberoende av varandra.
• Ökad uttrycksfullhet i koden: Guards låter dig uttrycka komplex villkorlig logik på ett mer koncist och deklarativt sätt.
• Bättre felhantering: Guards kan hjälpa dig att identifiera och hantera olika fall mer effektivt, vilket leder till mer robust kod.

Användningsfall för mönstermatchnings-guards

Mönstermatchnings-guards är användbara i en mängd olika scenarier, inklusive:

• Datavalidering: Validering av användarinmatning, API-svar eller data från externa källor.
• Routing-hantering: Bestämma vilken rutt som ska exekveras baserat på förfrågans parametrar.
• Tillståndshantering: Hantera tillståndet för en komponent eller applikation baserat på olika händelser och villkor.
• Spelutveckling: Hantera olika speltillstånd eller spelares handlingar baserat på specifika villkor.
• Finansiella applikationer: Beräkna räntor baserat på olika kontotyper och saldon. Till exempel kan en bank i Schweiz använda guards för att tillämpa olika räntesatser baserat på kontosaldogränser och valutatyp.
• E-handelsplattformar: Tillämpa rabatter baserat på kundlojalitet, köphistorik och kampanjkoder. En återförsäljare i Japan kan erbjuda särskilda rabatter till kunder som har handlat för ett visst belopp under det senaste året.
• Logistik och leveranskedjor: Optimera leveransrutter baserat på avstånd, trafikförhållanden och leveranstidsfönster. Ett företag i Tyskland kan använda guards för att prioritera leveranser till områden med hög trafikbelastning.
• Hälso- och sjukvårdsapplikationer: Triage av patienter baserat på symtom, sjukdomshistoria och riskfaktorer. Ett sjukhus i Kanada kan använda guards för att prioritera patienter med allvarliga symtom för omedelbar behandling.
• Utbildningsplattformar: Erbjuda personanpassade lärandeupplevelser baserat på elevens prestationer, lärstilar och preferenser. En skola i Finland kan använda guards för att anpassa svårighetsgraden på uppgifter baserat på en elevs framsteg.

Bibliotek för förbättrad mönstermatchning

Även om JavaScripts inbyggda funktioner är begränsade, finns det flera bibliotek som förbättrar mönstermatchningsförmågan och erbjuder mer sofistikerade guard-mekanismer. Några anmärkningsvärda bibliotek inkluderar:

• ts-pattern: Ett omfattande mönstermatchningsbibliotek för TypeScript och JavaScript, som erbjuder kraftfullt stöd för guards och typsäkerhet.
• jswitch: Ett lättviktsbibliotek som erbjuder en mer uttrycksfull switch-sats med guard-funktionalitet.

Exempel med ts-pattern (kräver TypeScript):

            
import { match, P } from 'ts-pattern';

interface User {
  age: number;
  email?: string;
  country: string;
}

const user: User = { age: 25, email: 'test@example.com', country: 'USA' };

const result = match(user)
  .with({ age: P.gt(18), email: P.string }, (u) => `Vuxen användare med e-post från ${u.country}`)
  .with({ age: P.gt(18) }, (u) => `Vuxen användare från ${u.country}`)
  .with({ age: P.lt(18) }, (u) => `Minderårig användare från ${u.country}`)
  .otherwise(() => 'Ogiltig användare');

console.log(result); // Utskrift: Vuxen användare med e-post från USA

            

              
                Copy
              
            
          

Detta exempel visar hur ts-pattern låter dig definiera mönster med guards med hjälp av P-objektet, som tillhandahåller olika matchningspredikat som P.gt (större än) och P.string (är en sträng). Biblioteket erbjuder också typsäkerhet, vilket säkerställer att dina mönster är korrekt typade.

Bästa praxis för att använda mönstermatchnings-guards

• Håll guards enkla: Komplexa guard-uttryck kan göra din kod svårare att förstå. Bryt ner komplexa villkor i mindre, mer hanterbara guards.
• Använd beskrivande namn för guards: Ge dina guard-funktioner eller variabler beskrivande namn som tydligt indikerar deras syfte.
• Dokumentera dina guards: Lägg till kommentarer för att förklara syftet och beteendet hos dina guards, särskilt om de är komplexa.
• Testa dina guards noggrant: Se till att dina guards fungerar korrekt genom att skriva omfattande enhetstester som täcker alla möjliga scenarier.
• Överväg att använda bibliotek: Om du behöver mer avancerade mönstermatchningsfunktioner, överväg att använda ett bibliotek som ts-pattern eller jswitch.
• Balansera komplexiteten: Överkomplicera inte din kod med onödiga guards. Använd dem omdömesgillt för att förbättra läsbarhet och underhållbarhet.
• Tänk på prestanda: Även om guards i allmänhet inte medför någon betydande prestandaförlust, var medveten om komplexa guard-uttryck som kan påverka prestandan i kritiska delar av din kod.

Slutsats

Mönstermatchnings-guards är en kraftfull teknik för att förbättra utvärderingen av villkorliga uttryck i JavaScript. Även om JavaScripts inbyggda funktioner är begränsade, kan du simulera detta beteende med hjälp av switch-satser, if-else-kedjor och funktioner som guards. Genom att följa bästa praxis och överväga användningen av bibliotek som ts-pattern kan du utnyttja mönstermatchnings-guards för att skapa mer läsbar, underhållbar och uttrycksfull kod. Omfamna dessa tekniker för att skriva mer robusta och eleganta JavaScript-applikationer som kan hantera ett brett spektrum av scenarier med tydlighet och precision.

I takt med att JavaScript fortsätter att utvecklas kan vi förvänta oss att se mer inbyggt stöd för mönstermatchning och guards, vilket gör denna teknik ännu mer tillgänglig och kraftfull för utvecklare världen över. Utforska möjligheterna och börja införliva mönstermatchnings-guards i dina JavaScript-projekt idag!